package com.google.zxing.client.android.process;

import android.graphics.Bitmap;
import android.graphics.Matrix;

import java.util.Vector;

/**
 * Created by yanmaoshen on 2017/11/20.
 */
public class PerspectiveTransform {

    private float a11 = 0.0f;
    private float a12 = 0.0f;
    private float a13 = 0.0f;
    private float a21 = 0.0f;
    private float a22 = 0.0f;
    private float a23 = 0.0f;
    private float a31 = 0.0f;
    private float a32 = 0.0f;
    private float a33 = 0.0f;
    public PerspectiveTransform(float inA11, float inA21,
                                               float inA31, float inA12,
                                               float inA22, float inA32,
                                               float inA13, float inA23,
                                               float inA33) {

        a11 = inA11;
        a12 = inA12;
        a13 = inA13;
        a21 = inA21;
        a22 = inA22;
        a23 = inA23;
        a31 = inA31;
        a32 = inA32;
        a33 = inA33;
    }

    public PerspectiveTransform quadrilateralToQuadrilateral(float x0, float y0, float x1, float y1,
                                                                            float x2, float y2, float x3, float y3, float x0p, float y0p, float x1p, float y1p, float x2p, float y2p,
                                                                            float x3p, float y3p) {
        PerspectiveTransform qToS = quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
        PerspectiveTransform sToQ =
                squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
        return times(qToS);
    }

    private PerspectiveTransform squareToQuadrilateral(float x0, float y0, float x1, float y1, float x2,
                                                                     float y2, float x3, float y3) {
        float dx3 = x0 - x1 + x2 - x3;
        float dy3 = y0 - y1 + y2 - y3;
        if (dx3 == 0.0f && dy3 == 0.0f) {
            PerspectiveTransform result = new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f,
                    0.0f, 1.0f);
            return result;
        } else {
            float dx1 = x1 - x2;
            float dx2 = x3 - x2;
            float dy1 = y1 - y2;
            float dy2 = y3 - y2;
            float denominator = dx1 * dy2 - dx2 * dy1;
            float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
            float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
            PerspectiveTransform result = new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0
                    + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0f);
            return result;
        }
    }

    private PerspectiveTransform quadrilateralToSquare(float x0, float y0, float x1, float y1, float x2,
                                                                     float y2, float x3, float y3) {
        // Here, the adjoint serves as the inverse:
        return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3).buildAdjoint();
    }

    private PerspectiveTransform buildAdjoint() {
        // Adjoint is the transpose of the cofactor matrix:
        PerspectiveTransform result = new PerspectiveTransform(a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32
                        - a22 * a31, a13 * a32 - a12 * a33, a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22,
                a13 * a21 - a11 * a23, a11 * a22 - a12 * a21);
        return result;
    }

    private PerspectiveTransform times(PerspectiveTransform other) {
        PerspectiveTransform result = new PerspectiveTransform(a11 * other.a11 + a21 * other.a12 + a31 * other.a13,
                a11 * other.a21 + a21 * other.a22 + a31 * other.a23, a11 * other.a31 + a21 * other.a32 + a31
                        * other.a33, a12 * other.a11 + a22 * other.a12 + a32 * other.a13, a12 * other.a21 + a22
                        * other.a22 + a32 * other.a23, a12 * other.a31 + a22 * other.a32 + a32 * other.a33, a13
                        * other.a11 + a23 * other.a12 + a33 * other.a13, a13 * other.a21 + a23 * other.a22 + a33
                        * other.a23, a13 * other.a31 + a23 * other.a32 + a33 * other.a33);
        return result;
    }

    public void transformPoints(Vector<Float> points) {
        int max = points.size();
        for (int i = 0; i < max; i += 2) {
            float x = points.get(i);
            float y = points.get(i+1);
            float denominator = a13 * x + a23 * y + a33;
            points.set(i, (a11 * x + a21 * y + a31) / denominator );
            points.set(i + 1,  (a12 * x + a22 * y + a32) / denominator );
        }
    }

}
